home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2005 October / PCWOCT05.iso / Software / FromTheMag / XAMPP 1.4.14 / xampp-win32-1.4.14-installer.exe / xampp / php / pear / DB / Pager.php < prev    next >
PHP Script  |  2004-03-24  |  8KB  |  251 lines
  1. <?php
  2. //
  3. //  Pear DB Pager - Retrieve and return information of databases
  4. //                  result sets
  5. //
  6. //  Copyright (C) 2001  Tomas Von Veschler Cox <cox@idecnet.com>
  7. //
  8. //  This library is free software; you can redistribute it and/or
  9. //  modify it under the terms of the GNU Lesser General Public
  10. //  License as published by the Free Software Foundation; either
  11. //  version 2.1 of the License, or (at your option) any later version.
  12. //
  13. //  This library is distributed in the hope that it will be useful,
  14. //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16. //  Lesser General Public License for more details.
  17. //
  18. //  You should have received a copy of the GNU Lesser General Public
  19. //  License along with this library; if not, write to the Free Software
  20. //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  21. //
  22. //
  23. // $Id: Pager.php,v 1.3 2002/05/12 13:59:40 cox Exp $
  24.  
  25. require_once 'PEAR.php';
  26. require_once 'DB.php';
  27.  
  28. /**
  29. * This class handles all the stuff needed for displaying paginated results
  30. * from a database query of Pear DB, in a very easy way.
  31. * Documentation and examples of use, can be found in:
  32. * http://vulcanonet.com/soft/pager/ (could be outdated)
  33. *
  34. * IMPORTANT!
  35. * Since PEAR DB already support native row limit (more fast and avaible in
  36. * all the drivers), there is no more need to use $pager->build() or
  37. * the $pager->fetch*() methods.
  38. *
  39. * Usage example:
  40. *
  41. *< ?php
  42. * require_once 'DB/Pager.php';
  43. * $db = DB::connect('your DSN string');
  44. * $from = 0;   // The row to start to fetch from (you might want to get this
  45. *              // param from the $_GET array
  46. * $limit = 10; // The number of results per page
  47. * $maxpages = 10; // The number of pages for displaying in the pager (optional)
  48. * $res = $db->limitQuery($sql, $from, $limit);
  49. * $nrows = 0; // Alternative you could use $res->numRows()
  50. * while ($row = $res->fetchrow()) {
  51. *    // XXX code for building the page here
  52. *     $nrows++;
  53. * }
  54. * $data = DB_Pager::getData($from, $limit, $nrows, $maxpages);
  55. * // XXX code for building the pager here
  56. * ? >
  57. *
  58. * @version 0.7
  59. * @author Tomas V.V.Cox <cox@idecnet.com>
  60. * @see http://vulcanonet.com/soft/pager/
  61. */
  62.  
  63. class DB_Pager extends PEAR
  64. {
  65.  
  66.     /**
  67.     * Constructor
  68.     *
  69.     * @param object $res  A DB_result object from Pear_DB
  70.     * @param int    $from  The row to start fetching
  71.     * @param int    $limit  How many results per page
  72.     * @param int    $numrows Pager will automatically
  73.     *    find this param if is not given. If your Pear_DB backend extension
  74.     *    doesn't support numrows(), you can manually calculate it
  75.     *    and supply later to the constructor
  76.     * @deprecated
  77.     */
  78.     function DB_Pager (&$res, $from, $limit, $numrows = null)
  79.     {
  80.         $this->res = $res;
  81.         $this->from = $from;
  82.         $this->limit = $limit;
  83.         $this->numrows = $numrows;
  84.     }
  85.  
  86.     /**
  87.     * Calculates all the data needed by Pager to work
  88.     *
  89.     * @return mixed An assoc array with all the data (see getData)
  90.     *    or DB_Error on error
  91.     * @see DB_Pager::getData
  92.     * @deprecated
  93.     */
  94.     function build()
  95.     {
  96.         // if there is no numrows given, calculate it
  97.         if ($this->numrows === null) {
  98.             $this->numrows = $this->res->numrows();
  99.             if (DB::isError($this->numrows)) {
  100.                 return $this->numrows;
  101.             }
  102.         }
  103.         $data = $this->getData($this->from, $this->limit, $this->numrows);
  104.         if (DB::isError($data)) {
  105.             return $data;
  106.         }
  107.         $this->current = $this->from - 1;
  108.         $this->top = $data['to'];
  109.         return $data;
  110.     }
  111.  
  112.     /**
  113.     * @deprecated
  114.     */
  115.     function fetchRow($mode=DB_FETCHMODE_DEFAULT)
  116.     {
  117.         $this->current++;
  118.         if ($this->current >= $this->top) {
  119.             return null;
  120.         }
  121.         return $this->res->fetchRow($mode, $this->current);
  122.     }
  123.  
  124.     /**
  125.     * @deprecated
  126.     */
  127.     function fetchInto(&$arr, $mode=DB_FETCHMODE_DEFAULT)
  128.     {
  129.         $this->current++;
  130.         if ($this->current >= $this->top) {
  131.             return null;
  132.         }
  133.         return $this->res->fetchInto($arr, $mode, $this->current);
  134.     }
  135.  
  136.     /*
  137.     * Gets all the data needed to paginate results
  138.     * This is an associative array with the following
  139.     * values filled in:
  140.     *
  141.     * array(
  142.     *    'current' => X,    // current page you are
  143.     *    'numrows' => X,    // total number of results
  144.     *    'next'    => X,    // row number where next page starts
  145.     *    'prev'    => X,    // row number where prev page starts
  146.     *    'remain'  => X,    // number of results remaning *in next page*
  147.     *    'numpages'=> X,    // total number of pages
  148.     *    'from'    => X,    // the row to start fetching
  149.     *    'to'      => X,    // the row to stop fetching
  150.     *    'limit'   => X,    // how many results per page
  151.     *    'maxpages'   => X, // how many pages to show (google style)
  152.     *    'firstpage'  => X, // the row number of the first page
  153.     *    'lastpage'   => X, // the row number where the last page starts
  154.     *    'pages'   => array(    // assoc with page "number => start row"
  155.     *                1 => X,
  156.     *                2 => X,
  157.     *                3 => X
  158.     *                )
  159.     *    );
  160.     * @param int $from    The row to start fetching
  161.     * @param int $limit   How many results per page
  162.     * @param int $numrows Number of results from query
  163.     *
  164.     * @return array associative array with data or DB_error on error
  165.     *
  166.     */
  167.     function &getData($from, $limit, $numrows, $maxpages = false)
  168.     {
  169.         if (empty($numrows) || ($numrows < 0)) {
  170.             return null;
  171.         }
  172.         $from = (empty($from)) ? 0 : $from;
  173.  
  174.         if ($limit <= 0) {
  175.             return PEAR::raiseError (null, 'wrong "limit" param', null,
  176.                                      null, null, 'DB_Error', true);
  177.         }
  178.  
  179.         // Total number of pages
  180.         $pages = ceil($numrows/$limit);
  181.         $data['numpages'] = $pages;
  182.  
  183.         // first & last page
  184.         $data['firstpage'] = 1;
  185.         $data['lastpage']  = $pages;
  186.  
  187.         // Build pages array
  188.         $data['pages'] = array();
  189.         for ($i=1; $i <= $pages; $i++) {
  190.             $offset = $limit * ($i-1);
  191.             $data['pages'][$i] = $offset;
  192.             // $from must point to one page
  193.             if ($from == $offset) {
  194.                 // The current page we are
  195.                 $data['current'] = $i;
  196.             }
  197.         }
  198.         if (!isset($data['current'])) {
  199.             return PEAR::raiseError (null, 'wrong "from" param', null,
  200.                                      null, null, 'DB_Error', true);
  201.         }
  202.  
  203.         // Limit number of pages (goole algoritm)
  204.         if ($maxpages) {
  205.             $radio = floor($maxpages/2);
  206.             $minpage = $data['current'] - $radio;
  207.             if ($minpage < 1) {
  208.                 $minpage = 1;
  209.             }
  210.             $maxpage = $data['current'] + $radio - 1;
  211.             if ($maxpage > $data['numpages']) {
  212.                 $maxpage = $data['numpages'];
  213.             }
  214.             foreach (range($minpage, $maxpage) as $page) {
  215.                 $tmp[$page] = $data['pages'][$page];
  216.             }
  217.             $data['pages'] = $tmp;
  218.             $data['maxpages'] = $maxpages;
  219.         } else {
  220.             $data['maxpages'] = null;
  221.         }
  222.  
  223.         // Prev link
  224.         $prev = $from - $limit;
  225.         $data['prev'] = ($prev >= 0) ? $prev : null;
  226.  
  227.         // Next link
  228.         $next = $from + $limit;
  229.         $data['next'] = ($next < $numrows) ? $next : null;
  230.  
  231.         // Results remaining in next page & Last row to fetch
  232.         if ($data['current'] == $pages) {
  233.             $data['remain'] = 0;
  234.             $data['to'] = $numrows;
  235.         } else {
  236.             if ($data['current'] == ($pages - 1)) {
  237.                 $data['remain'] = $numrows - ($limit*($pages-1));
  238.             } else {
  239.                 $data['remain'] = $limit;
  240.             }
  241.             $data['to'] = $data['current'] * $limit;
  242.         }
  243.         $data['numrows'] = $numrows;
  244.         $data['from']    = $from + 1;
  245.         $data['limit']   = $limit;
  246.  
  247.         return $data;
  248.     }
  249. }
  250. ?>
  251.